home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / lib / ubiquity / plugins / ubi-console-setup.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-10-28  |  21.0 KB  |  638 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import re
  5. import os
  6. from ubiquity.plugin import *
  7. from ubiquity import keyboard_names
  8. from ubiquity import misc
  9. NAME = 'console_setup'
  10. AFTER = 'timezone'
  11. WEIGHT = 10
  12.  
  13. class PageGtk(PluginUI):
  14.     
  15.     def __init__(self, controller, *args, **kwargs):
  16.         self.controller = controller
  17.         self.current_layout = None
  18.         self.default_keyboard_layout = None
  19.         self.default_keyboard_variant = None
  20.         
  21.         try:
  22.             import gtk
  23.             builder = gtk.Builder()
  24.             builder.add_from_file('/usr/share/ubiquity/gtk/stepKeyboardConf.ui')
  25.             builder.connect_signals(self)
  26.             self.page = builder.get_object('stepKeyboardConf')
  27.             self.suggested_keymap = builder.get_object('suggested_keymap')
  28.             self.suggested_keymap_label = builder.get_object('suggested_keymap_label')
  29.             self.keyboard_layout_hbox = builder.get_object('keyboard_layout_hbox')
  30.             self.keyboardlayoutview = builder.get_object('keyboardlayoutview')
  31.             self.keyboardvariantview = builder.get_object('keyboardvariantview')
  32.         except Exception:
  33.             e = None
  34.             self.debug('Could not create keyboard page: %s', e)
  35.             self.page = None
  36.  
  37.         self.plugin_widgets = self.page
  38.  
  39.     
  40.     def on_keyboardlayoutview_row_activated(self, *args):
  41.         self.controller.go_forward()
  42.  
  43.     
  44.     def on_keyboard_layout_selected(self, *args):
  45.         layout = self.get_keyboard()
  46.         if layout is not None:
  47.             self.current_layout = layout
  48.             self.controller.dbfilter.change_layout(layout)
  49.         
  50.  
  51.     
  52.     def on_keyboardvariantview_row_activated(self, *args):
  53.         self.controller.go_forward()
  54.  
  55.     
  56.     def on_keyboard_variant_selected(self, *args):
  57.         layout = self.get_keyboard()
  58.         variant = self.get_keyboard_variant()
  59.         if layout is not None and variant is not None:
  60.             self.controller.dbfilter.apply_keyboard(layout, variant)
  61.         
  62.  
  63.     
  64.     def set_keyboard_choices(self, choices):
  65.         import gtk
  66.         import gobject
  67.         layouts = gtk.ListStore(gobject.TYPE_STRING)
  68.         self.keyboardlayoutview.set_model(layouts)
  69.         for v in sorted(choices):
  70.             layouts.append([
  71.                 v])
  72.         
  73.         if len(self.keyboardlayoutview.get_columns()) < 1:
  74.             column = gtk.TreeViewColumn('Layout', gtk.CellRendererText(), text = 0)
  75.             column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
  76.             self.keyboardlayoutview.append_column(column)
  77.             selection = self.keyboardlayoutview.get_selection()
  78.             selection.connect('changed', self.on_keyboard_layout_selected)
  79.         
  80.         if self.current_layout is not None:
  81.             self.set_keyboard(self.current_layout)
  82.         
  83.  
  84.     
  85.     def set_keyboard(self, layout):
  86.         if self.default_keyboard_layout is None:
  87.             self.default_keyboard_layout = layout
  88.         
  89.         self.current_layout = layout
  90.         model = self.keyboardlayoutview.get_model()
  91.         if model is None:
  92.             return None
  93.         iterator = model.iter_children(None)
  94.         while iterator is not None:
  95.             if unicode(model.get_value(iterator, 0)) == layout:
  96.                 path = model.get_path(iterator)
  97.                 self.keyboardlayoutview.get_selection().select_path(path)
  98.                 self.keyboardlayoutview.scroll_to_cell(path, use_align = True, row_align = 0.5)
  99.                 break
  100.             
  101.             iterator = model.iter_next(iterator)
  102.  
  103.     
  104.     def get_keyboard(self):
  105.         if self.suggested_keymap.get_active():
  106.             if self.default_keyboard_layout is not None:
  107.                 return None
  108.             return unicode(self.default_keyboard_layout)
  109.         self.suggested_keymap.get_active()
  110.         selection = self.keyboardlayoutview.get_selection()
  111.         (model, iterator) = selection.get_selected()
  112.         if iterator is None:
  113.             return None
  114.         return unicode(model.get_value(iterator, 0))
  115.  
  116.     
  117.     def set_keyboard_variant_choices(self, choices):
  118.         import gtk
  119.         import gobject
  120.         variants = gtk.ListStore(gobject.TYPE_STRING)
  121.         self.keyboardvariantview.set_model(variants)
  122.         for v in sorted(choices):
  123.             variants.append([
  124.                 v])
  125.         
  126.         if len(self.keyboardvariantview.get_columns()) < 1:
  127.             column = gtk.TreeViewColumn('Variant', gtk.CellRendererText(), text = 0)
  128.             column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
  129.             self.keyboardvariantview.append_column(column)
  130.             selection = self.keyboardvariantview.get_selection()
  131.             selection.connect('changed', self.on_keyboard_variant_selected)
  132.         
  133.  
  134.     
  135.     def set_keyboard_variant(self, variant):
  136.         if self.default_keyboard_variant is None:
  137.             self.default_keyboard_variant = variant
  138.         
  139.         if self.suggested_keymap.get_active():
  140.             self.suggested_keymap_label.set_property('label', variant)
  141.             self.suggested_keymap.toggled()
  142.         
  143.         model = self.keyboardvariantview.get_model()
  144.         if model is None:
  145.             return None
  146.         iterator = model.iter_children(None)
  147.         while iterator is not None:
  148.             if unicode(model.get_value(iterator, 0)) == variant:
  149.                 path = model.get_path(iterator)
  150.                 self.keyboardvariantview.get_selection().select_path(path)
  151.                 self.keyboardvariantview.scroll_to_cell(path, use_align = True, row_align = 0.5)
  152.                 break
  153.             
  154.             iterator = model.iter_next(iterator)
  155.  
  156.     
  157.     def get_keyboard_variant(self):
  158.         if self.suggested_keymap.get_active():
  159.             if self.default_keyboard_variant is None:
  160.                 return None
  161.             return unicode(self.default_keyboard_variant)
  162.         self.suggested_keymap.get_active()
  163.         selection = self.keyboardvariantview.get_selection()
  164.         (model, iterator) = selection.get_selected()
  165.         if iterator is None:
  166.             return None
  167.         return unicode(model.get_value(iterator, 0))
  168.  
  169.     
  170.     def on_suggested_keymap_toggled(self, widget):
  171.         if self.suggested_keymap.get_active():
  172.             self.keyboard_layout_hbox.set_sensitive(False)
  173.             if self.default_keyboard_layout is not None and self.default_keyboard_variant is not None:
  174.                 self.current_layout = self.default_keyboard_layout
  175.                 self.controller.dbfilter.change_layout(self.default_keyboard_layout)
  176.                 self.controller.dbfilter.apply_keyboard(self.default_keyboard_layout, self.default_keyboard_variant)
  177.             
  178.         else:
  179.             self.keyboard_layout_hbox.set_sensitive(True)
  180.  
  181.  
  182.  
  183. class PageKde(PluginUI):
  184.     plugin_breadcrumb = 'ubiquity/text/breadcrumb_keyboard'
  185.     
  186.     def __init__(self, controller, *args, **kwargs):
  187.         self.controller = controller
  188.         self.current_layout = None
  189.         self.default_keyboard_layout = None
  190.         self.default_keyboard_variant = None
  191.         
  192.         try:
  193.             uic = uic
  194.             import PyQt4
  195.             QVBoxLayout = QVBoxLayout
  196.             import PyQt4.QtGui
  197.             Keyboard = Keyboard
  198.             import ubiquity.frontend.kde_components.Keyboard
  199.             self.page = uic.loadUi('/usr/share/ubiquity/qt/stepKeyboardConf.ui')
  200.             self.keyboardDisplay = Keyboard(self.page.keyboard_frame)
  201.             self.page.keyboard_frame.setLayout(QVBoxLayout())
  202.             self.page.keyboard_frame.layout().addWidget(self.keyboardDisplay)
  203.             self.page.keyboard_layout_combobox.activated.connect(self.on_keyboard_layout_selected)
  204.             self.page.keyboard_variant_combobox.activated.connect(self.on_keyboard_variant_selected)
  205.         except Exception:
  206.             e = None
  207.             self.debug('Could not create keyboard page: %s', e)
  208.             self.page = None
  209.  
  210.         self.plugin_widgets = self.page
  211.  
  212.     
  213.     def on_keyboard_layout_selected(self):
  214.         layout = self.get_keyboard()
  215.         if layout is not None:
  216.             if self.keyboardDisplay:
  217.                 ly = keyboard_names.layouts[unicode(layout)]
  218.                 self.keyboardDisplay.setLayout(ly)
  219.             
  220.             self.current_layout = layout
  221.             self.controller.dbfilter.change_layout(layout)
  222.         
  223.  
  224.     
  225.     def on_keyboard_variant_selected(self):
  226.         layout = self.get_keyboard()
  227.         variant = self.get_keyboard_variant()
  228.         if self.keyboardDisplay:
  229.             var = None
  230.             ly = keyboard_names.layouts[layout]
  231.             if variant and keyboard_names.variants.has_key(ly):
  232.                 variantMap = keyboard_names.variants[ly]
  233.                 var = variantMap[unicode(variant)]
  234.             
  235.             self.keyboardDisplay.setVariant(var)
  236.         
  237.         if layout is not None and variant is not None:
  238.             self.controller.dbfilter.apply_keyboard(layout, variant)
  239.         
  240.  
  241.     
  242.     def set_keyboard_choices(self, choices):
  243.         QString = QString
  244.         import PyQt4.QtCore
  245.         self.page.keyboard_layout_combobox.clear()
  246.         for choice in sorted(choices):
  247.             self.page.keyboard_layout_combobox.addItem(QString(unicode(choice)))
  248.         
  249.         if self.current_layout is not None:
  250.             self.set_keyboard(self.current_layout)
  251.         
  252.  
  253.     
  254.     def set_keyboard(self, layout):
  255.         QString = QString
  256.         import PyQt4.QtCore
  257.         index = self.page.keyboard_layout_combobox.findText(QString(unicode(layout)))
  258.         if index > -1:
  259.             self.page.keyboard_layout_combobox.setCurrentIndex(index)
  260.         
  261.         if self.keyboardDisplay:
  262.             ly = keyboard_names.layouts[unicode(layout)]
  263.             self.keyboardDisplay.setLayout(ly)
  264.         
  265.  
  266.     
  267.     def get_keyboard(self):
  268.         if self.page.keyboard_layout_combobox.currentIndex() < 0:
  269.             return None
  270.         return unicode(self.page.keyboard_layout_combobox.currentText())
  271.  
  272.     
  273.     def set_keyboard_variant_choices(self, choices):
  274.         QString = QString
  275.         import PyQt4.QtCore
  276.         self.page.keyboard_variant_combobox.clear()
  277.         for choice in sorted(choices):
  278.             self.page.keyboard_variant_combobox.addItem(QString(unicode(choice)))
  279.         
  280.  
  281.     
  282.     def set_keyboard_variant(self, variant):
  283.         QString = QString
  284.         import PyQt4.QtCore
  285.         index = self.page.keyboard_variant_combobox.findText(QString(unicode(variant)))
  286.         if index > -1:
  287.             self.page.keyboard_variant_combobox.setCurrentIndex(index)
  288.         
  289.         if self.keyboardDisplay:
  290.             var = None
  291.             layout = keyboard_names.layouts[self.get_keyboard()]
  292.             if variant and keyboard_names.variants.has_key(layout):
  293.                 variantMap = keyboard_names.variants[layout]
  294.                 var = variantMap[unicode(variant)]
  295.             
  296.             self.keyboardDisplay.setVariant(var)
  297.         
  298.  
  299.     
  300.     def get_keyboard_variant(self):
  301.         if self.page.keyboard_variant_combobox.currentIndex() < 0:
  302.             return None
  303.         return unicode(self.page.keyboard_variant_combobox.currentText())
  304.  
  305.  
  306.  
  307. class PageDebconf(PluginUI):
  308.     plugin_title = 'ubiquity/text/keyboard_heading_label'
  309.  
  310.  
  311. class PageNoninteractive(PluginUI):
  312.     
  313.     def set_keyboard_choices(self, choices):
  314.         '''Set the available keyboard layout choices.'''
  315.         pass
  316.  
  317.     
  318.     def set_keyboard(self, layout):
  319.         '''Set the current keyboard layout.'''
  320.         self.current_layout = layout
  321.  
  322.     
  323.     def get_keyboard(self):
  324.         '''Get the current keyboard layout.'''
  325.         return self.current_layout
  326.  
  327.     
  328.     def set_keyboard_variant_choices(self, choices):
  329.         '''Set the available keyboard variant choices.'''
  330.         pass
  331.  
  332.     
  333.     def set_keyboard_variant(self, variant):
  334.         '''Set the current keyboard variant.'''
  335.         self.keyboard_variant = variant
  336.  
  337.     
  338.     def get_keyboard_variant(self):
  339.         return self.keyboard_variant
  340.  
  341.  
  342.  
  343. class Page(Plugin):
  344.     
  345.     def prepare(self, unfiltered = False):
  346.         self.preseed('console-setup/ask_detect', 'false')
  347.         misc.regain_privileges()
  348.         
  349.         try:
  350.             os.unlink('/etc/default/console-setup.pre-ubiquity')
  351.         except OSError:
  352.             pass
  353.  
  354.         
  355.         try:
  356.             os.rename('/etc/default/console-setup', '/etc/default/console-setup.pre-ubiquity')
  357.         except OSError:
  358.             
  359.             try:
  360.                 os.unlink('/etc/default/console-setup')
  361.             except OSError:
  362.                 pass
  363.             except:
  364.                 None<EXCEPTION MATCH>OSError
  365.             
  366.  
  367.             None<EXCEPTION MATCH>OSError
  368.  
  369.         misc.drop_privileges()
  370.         self.db.fset('console-setup/layout', 'seen', 'false')
  371.         self.db.fset('console-setup/variant', 'seen', 'false')
  372.         self.db.fset('console-setup/model', 'seen', 'false')
  373.         self.db.fset('console-setup/codeset', 'seen', 'false')
  374.         return ([
  375.             '/usr/lib/ubiquity/console-setup/console-setup.postinst',
  376.             'configure'], [
  377.             '^console-setup/layout',
  378.             '^console-setup/variant',
  379.             '^console-setup/unsupported_'], {
  380.             'OVERRIDE_ALLOW_PRESEEDING': '1' })
  381.  
  382.     
  383.     def run(self, priority, question):
  384.         if self.done:
  385.             return self.succeeded
  386.         if question == 'console-setup/layout':
  387.             self.succeeded = True
  388.             self.ui.set_keyboard_choices(self.choices_untranslated(question))
  389.             self.ui.set_keyboard(self.db.get(question))
  390.             return True
  391.         if question == 'console-setup/variant':
  392.             self.ui.set_keyboard_variant_choices(self.choices_untranslated(question))
  393.             self.ui.set_keyboard_variant(self.db.get(question))
  394.             if 'UBIQUITY_AUTOMATIC' in os.environ and self.db.fget('console-setup/layoutcode', 'seen') == 'true':
  395.                 return True
  396.             return Plugin.run(self, priority, question)
  397.         question == 'console-setup/variant'
  398.         if question.startswith('console-setup/unsupported_'):
  399.             response = self.frontend.question_dialog(self.description(question), self.extended_description(question), ('ubiquity/imported/yes', 'ubiquity/imported/no'))
  400.             return True
  401.         return True
  402.  
  403.     
  404.     def change_layout(self, layout):
  405.         self.preseed('console-setup/layout', layout)
  406.         self.succeeded = False
  407.         self.exit_ui_loops()
  408.  
  409.     
  410.     def ok_handler(self):
  411.         variant = self.ui.get_keyboard_variant()
  412.         if variant is not None:
  413.             self.preseed('console-setup/variant', variant)
  414.         
  415.         return Plugin.ok_handler(self)
  416.  
  417.     
  418.     def adjust_keyboard(self, model, layout, variant, options):
  419.         '''Apply any necessary tweaks to the supplied model, layout, variant,
  420.         and options.'''
  421.         if layout in ('am', 'ara', 'ben', 'bd', 'bg', 'bt', 'by', 'deva', 'ge', 'gh', 'gr', 'guj', 'guru', 'il', 'in', 'ir', 'iku', 'kan', 'kh', 'kz', 'la', 'lao', 'lk', 'mk', 'mm', 'mn', 'mv', 'mal', 'ori', 'pk', 'ru', 'scc', 'sy', 'syr', 'tel', 'th', 'tj', 'tam', 'ua', 'uz'):
  422.             latin = False
  423.             real_layout = 'us,%s' % layout
  424.         elif layout == 'jp':
  425.             if variant in ('106', 'common', 'OADG109A', 'nicola_f_bs', ''):
  426.                 latin = True
  427.                 real_layout = layout
  428.             else:
  429.                 latin = False
  430.                 real_layout = 'jp,jp'
  431.         elif layout == 'lt':
  432.             latin = False
  433.             real_layout = 'lt,lt'
  434.         elif layout == 'me':
  435.             if variant == 'basic' or variant.startswith('latin'):
  436.                 latin = True
  437.                 real_layout = layout
  438.             else:
  439.                 latin = False
  440.                 real_layout = 'me,me'
  441.         elif layout == 'rs':
  442.             if variant == 'basic' or variant.startswith('latin'):
  443.                 latin = True
  444.                 real_layout = layout
  445.             else:
  446.                 latin = False
  447.                 real_layout = 'rs,rs'
  448.         else:
  449.             latin = True
  450.             real_layout = layout
  451.         if latin:
  452.             real_variant = variant
  453.         elif real_layout == 'jp,jp':
  454.             real_variant = '106,%s' % variant
  455.         elif real_layout == 'lt,lt':
  456.             if variant == 'us':
  457.                 real_variant = 'us,'
  458.             else:
  459.                 real_variant = '%s,us' % variant
  460.         elif real_layout == 'me,me':
  461.             if variant == 'cyrillicyz':
  462.                 real_variant = 'latinyz,%s' % variant
  463.             elif variant == 'cyrillicalternatequotes':
  464.                 real_variant = 'latinalternatequotes,%s' % variant
  465.             else:
  466.                 real_variant = 'basic,%s' % variant
  467.         elif real_layout == 'rs,rs':
  468.             if variant == 'yz':
  469.                 real_variant = 'latinyz,%s' % variant
  470.             elif variant == 'alternatequotes':
  471.                 real_variant = 'latinalternatequotes,%s' % variant
  472.             else:
  473.                 real_variant = 'latin,%s' % variant
  474.         else:
  475.             real_variant = ',%s' % variant
  476.         real_options = _[1]
  477.         real_model = model
  478.         if model == 'pc105':
  479.             if real_layout == 'br':
  480.                 real_model = 'abnt2'
  481.             elif real_layout == 'jp':
  482.                 real_model = 'jp106'
  483.             
  484.         
  485.         return (real_model, real_layout, real_variant, real_options)
  486.  
  487.     
  488.     def apply_keyboard(self, layout, variant):
  489.         model = self.db.get('console-setup/modelcode')
  490.         if layout not in keyboard_names.layouts:
  491.             self.debug("Unknown keyboard layout '%s'" % layout)
  492.             return None
  493.         layout = keyboard_names.layouts[layout]
  494.         if layout not in keyboard_names.variants:
  495.             self.debug("No known variants for layout '%s'" % layout)
  496.             variant = ''
  497.         elif variant in keyboard_names.variants[layout]:
  498.             variant = keyboard_names.variants[layout][variant]
  499.         else:
  500.             self.debug("Unknown keyboard variant '%s' for layout '%s'" % (variant, layout))
  501.             return None
  502.         (model, layout, variant, options) = (layout not in keyboard_names.layouts).adjust_keyboard(model, layout, variant, [])
  503.         self.debug('Setting keyboard layout: %s %s %s %s' % (model, layout, variant, options))
  504.         self.apply_real_keyboard(model, layout, variant, options)
  505.  
  506.     
  507.     def apply_real_keyboard(self, model, layout, variant, options):
  508.         args = []
  509.         if model is not None and model != '':
  510.             args.extend(('-model', model))
  511.         
  512.         args.extend(('-layout', layout))
  513.         if variant != '':
  514.             args.extend(('-variant', variant))
  515.         
  516.         args.extend(('-option', ''))
  517.         for option in options:
  518.             args.extend(('-option', option))
  519.         
  520.         misc.execute('setxkbmap', *args)
  521.  
  522.     
  523.     def cleanup(self):
  524.         model = self.db.get('console-setup/modelcode')
  525.         layout = self.db.get('console-setup/layoutcode')
  526.         variant = self.db.get('console-setup/variantcode')
  527.         options = self.db.get('console-setup/optionscode')
  528.         self.apply_real_keyboard(model, layout, variant, options.split(','))
  529.         Plugin.cleanup(self)
  530.         if layout == '':
  531.             return None
  532.         misc.regain_privileges()
  533.         oldconfigfile = '/etc/X11/xorg.conf'
  534.         newconfigfile = '/etc/X11/xorg.conf.new'
  535.         
  536.         try:
  537.             oldconfig = open(oldconfigfile)
  538.         except IOError:
  539.             layout == ''
  540.             layout == ''
  541.             return None
  542.  
  543.         newconfig = open(newconfigfile, 'w')
  544.         re_section_inputdevice = re.compile('\\s*Section\\s+"InputDevice"\\s*$')
  545.         re_driver_kbd = re.compile('\\s*Driver\\s+"kbd"\\s*$')
  546.         re_endsection = re.compile('\\s*EndSection\\s*$')
  547.         re_option_xkbmodel = re.compile('(\\s*Option\\s*"XkbModel"\\s*).*')
  548.         re_option_xkblayout = re.compile('(\\s*Option\\s*"XkbLayout"\\s*).*')
  549.         re_option_xkbvariant = re.compile('(\\s*Option\\s*"XkbVariant"\\s*).*')
  550.         re_option_xkboptions = re.compile('(\\s*Option\\s*"XkbOptions"\\s*).*')
  551.         in_inputdevice = False
  552.         in_inputdevice_kbd = False
  553.         done = {
  554.             'model': model == '',
  555.             'layout': False,
  556.             'variant': variant == '',
  557.             'options': options == '' }
  558.         for line in oldconfig:
  559.             line = line.rstrip('\n')
  560.             if re_section_inputdevice.match(line) is not None:
  561.                 in_inputdevice = True
  562.             elif in_inputdevice and re_driver_kbd.match(line) is not None:
  563.                 in_inputdevice_kbd = True
  564.             elif re_endsection.match(line) is not None:
  565.                 if in_inputdevice_kbd:
  566.                     if not done['model']:
  567.                         print >>newconfig, '\tOption\t\t"XkbModel"\t"%s"' % model
  568.                     
  569.                     if not done['layout']:
  570.                         print >>newconfig, '\tOption\t\t"XkbLayout"\t"%s"' % layout
  571.                     
  572.                     if not done['variant']:
  573.                         print >>newconfig, '\tOption\t\t"XkbVariant"\t"%s"' % variant
  574.                     
  575.                     if not done['options']:
  576.                         print >>newconfig, '\tOption\t\t"XkbOptions"\t"%s"' % options
  577.                     
  578.                 
  579.                 in_inputdevice = False
  580.                 in_inputdevice_kbd = False
  581.                 done = {
  582.                     'model': model == '',
  583.                     'layout': False,
  584.                     'variant': variant == '',
  585.                     'options': options == '' }
  586.             elif in_inputdevice_kbd:
  587.                 match = re_option_xkbmodel.match(line)
  588.                 if match is not None:
  589.                     if model == '':
  590.                         line = match.group(1) + '"pc105"'
  591.                     else:
  592.                         line = match.group(1) + '"%s"' % model
  593.                     done['model'] = True
  594.                 else:
  595.                     match = re_option_xkblayout.match(line)
  596.                     if match is not None:
  597.                         line = match.group(1) + '"%s"' % layout
  598.                         done['layout'] = True
  599.                     else:
  600.                         match = re_option_xkbvariant.match(line)
  601.                         if match is not None:
  602.                             if variant == '':
  603.                                 continue
  604.                             else:
  605.                                 line = match.group(1) + '"%s"' % variant
  606.                             done['variant'] = True
  607.                         else:
  608.                             match = re_option_xkboptions.match(line)
  609.                             if match is not None:
  610.                                 if options == '':
  611.                                     continue
  612.                                 else:
  613.                                     line = match.group(1) + '"%s"' % options
  614.                                 done['options'] = True
  615.                             
  616.             
  617.             print >>newconfig, line
  618.         
  619.         newconfig.close()
  620.         oldconfig.close()
  621.         os.rename(newconfigfile, oldconfigfile)
  622.         misc.drop_privileges()
  623.  
  624.  
  625.  
  626. class Install(InstallPlugin):
  627.     
  628.     def prepare(self, unfiltered = False):
  629.         return ([
  630.             '/usr/share/ubiquity/console-setup-apply'], [])
  631.  
  632.     
  633.     def install(self, target, progress, *args, **kwargs):
  634.         progress.info('ubiquity/install/keyboard')
  635.         return InstallPlugin.install(self, target, progress, *args, **kwargs)
  636.  
  637.  
  638.